const cofdb = require('../Model/db');//引入数据库信息
const sqlUser = require('../Model/user/mysql');//引入数据库语句
const exeLogin = require('../Model/user/login');//引入定义方法模块
const exeUser = require('../Model/user/query');//引入定义方法模块
const express = require('express');//引入express模块
const router = express.Router();//
const mysql = require('mysql');//引入mysql数据库模块
const md5 = require('blueimp-md5');//引入MD5模块

// router.use(express.bodyParser({ uploadDir: "./public/upload" }));

//连接数据库
connlink();
function connlink() {
    //连接数据库
    conn = mysql.createConnection(cofdb.mysql_cof);
    conn.connect((err) => {
        if (err) {
            throw err;
            setTimeout('connlink()', 1000);
        }
    });
    //断开重连
    conn.on('error', (err) => {
        console.log("数据库断开重连...");
        console.log(err);
        if (err.code === 'PROTOCOL_CONNECTION_LOST') {
            connlink();
        }
    });
}

/**
 * 自定义返回消息
 * @param {状态码} _code 
 * @param {提示消息} _msg 
 * @param {返回数据} _data 
 */
function sendData(_code, _msg, _data = {}, type = 0, _val = '') {
    switch (type) {
        case 0:
            var ret_data = {
                "code": _code,
                "msg": _msg,
                "data": _data
            };
            break;
        case 1:
            var ret_data = {
                "code": _code,
                "msg": _msg,
                "edit": _val,
                "data": _data
            };
            break;
        default:
            var ret_data = {}
            break;
    }
    return ret_data;
}

/**
 * 日志记录
 * @param {操作者} _user 
 * @param {句柄} conn 
 * @param {操作事件名} _name 
 * @param {事件说明} _desc 
 * @param {执行状态} _state 
 * @param {事件类型} _type 
 */
function _Log(conn, _form, _user, _name, _desc, _state, _type) {
    const sqllog = sqlUser.user.sys.add[0];
    exeUser.addUserData(conn, sqllog, [_form, _user, _name, _desc, _state, _type]).then((res => {
        if (res) {
            console.log('日志记录');
        }
    })).catch((reason => {
        console.log('日志记录错误');
    }));
}

/**
 * POST
 * 日志列表
 */
router.post('/log', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqllogRow = sqlUser.user.sys.check[0];
    const sqllogAll = sqlUser.user.sys.check[1];
    if (token != undefined && name != undefined && form != undefined) {
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //令牌验证通过
            if (res) {
                console.log(res['v_power']);
                if (res['v_power'] == 0) {
                    return exeUser.getUserList(conn, sqllogAll, []);
                } else {
                    return exeUser.getUserList(conn, sqllogRow, [name, form]);
                }
            }
        })).catch((reason => {
            //令牌验证失败
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            console.log(res);
            if (res) {
                _tips = sendData(200, '数据获取成功', res);
                response.json(_tips);
            } else {
                _tips = sendData(204, '数据获取失败');
                response.json(_tips);
            }
        }))
    }
});




/**
 * 密钥生成
 * @param {用户名} _name
 */
function instkey(_name) {
    var date = new Date();
    var time = date.getTime();
    var md5_data = _name + time;
    key = md5(md5_data);
    return key;
}

/**
 * POST
 * 用户退出
 */
router.post('/signout', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqlmod = sqlUser.user.token2[form];//
    let modOne;
    modOne = ['', token];

    if (token != undefined && name != undefined && form != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                //清空令牌
                return exeUser.modUserData(conn, sqlmod, modOne);
            } else {
                modTow = "身份验证错误"
                return false;
            }
        })).catch((reason => {
            // console.log(reason);
            //令牌验证失败
            _Log(conn, form, name, '用户退出', '退出失败', '失败', '修改');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            //修改操作执行成功
            if (res) {
                _Log(conn, form, name, '用户退出', '退出成功', '成功', '修改');
                _tips = sendData(200, '退出成功');
                response.json(_tips);
            } else {
                modTwo = '修改失败';
                _Log(conn, form, name, '用户退出', modTow, '失败', '修改');
                _tips = sendData(204, modTow);
                response.json(_tips);
            }
        }))
    }
})

/**
 * POST
 * 知识库内容修改
 */
router.post('/cruxmod', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const isid = request.body.isid;//id
    //待修改数据
    const iscrux = request.body.iscrux;//关键词
    const iscontent = request.body.iscontent;//回复内容
    const istype = request.body.istype;//消息类型

    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqlmod = sqlUser.user.knowledge.mod[0];//知识库修改语句

    let modOne, modTow;
    modOne = [iscrux, iscontent, istype, name, isid];

    if (token != undefined && name != undefined && form != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                return exeUser.modUserData(conn, sqlmod, modOne);
            } else {
                modTow = "身份验证错误"
                return false;
            }
        })).catch((reason => {
            // console.log(reason);
            //令牌验证失败
            _Log(conn, form, name, '知识库修改', '身份验证错误', '失败', '修改');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            //修改操作执行成功
            if (res) {
                _Log(conn, form, name, '知识库修改', '修改成功', '成功', '修改');
                _tips = sendData(200, '修改成功');
                response.json(_tips);
            } else {
                modTwo = '修改失败';
                _Log(conn, form, name, '知识库修改', modTow, '失败', '修改');
                _tips = sendData(204, modTow);
                response.json(_tips);
            }
        }))
    }
});

/**
 * POST
 * 知识库删除
 */
router.post('/cruxdel', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const isid = request.body.id;
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqldel = sqlUser.user.knowledge.del[0];//知识库删除语句
    if (token != undefined && name != undefined && form != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                return exeUser.delUserData(conn, sqldel, [isid.split(",")]);
            } else {
                modTow = "身份验证错误"
                return false;
            }
        })).catch((reason => {
            console.log(reason);
            //令牌验证失败
            _Log(conn, form, name, '知识库删除', '身份验证错误', '失败', '删除');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (res) {
                _Log(conn, form, name, '知识库删除', '删除成功', '成功', '删除');
                _tips = sendData(200, '删除成功');
                response.json(_tips);
            } else {
                _Log(conn, form, name, '知识库删除', '删除失败', '失败', '删除');
                _tips = sendData(204, '删除失败');
                response.json(_tips);
            }
        }))
    }
})

/**
 * POST
 * 知识库列表
 */
router.post('/cruxlist', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqlclist = sqlUser.user.knowledge.check;//令牌检查语句
    let modOne, modTow;
    if (token != undefined && name != undefined && form != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                if (res['v_power'] == 0 || res['v_power'] == 1) {
                    return exeUser.getUserList(conn, sqlclist[0], []);
                } else {
                    return exeUser.getUserList(conn, sqlclist[1], [res['v_form']]);
                }
            } else {
                modTow = "身份验证错误1"
                return false;
            }
        })).catch((reason => {
            console.log(reason);
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (res) {
                if (res.length > 0) {
                    _tips = sendData(200, '知识库查询成功', res);
                    response.json(_tips);
                } else {
                    _tips = sendData(204, '查询数据为空');
                    response.json(_tips);
                }
            } else {
                _tips = sendData(204, modTow);
                response.json(_tips);
            }
        }))
    }
})

/**
 * POST
 * 知识库添加
 */
router.post('/cruxadd', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    //待添加数据
    const iscrux = request.body.iscrux;//关键词
    const iscontent = request.body.iscontent;//回复内容
    const istype = request.body.istype;//消息类型

    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqladd = sqlUser.user.knowledge.add[0];//令牌检查语句
    let modOne, modTow;

    if (token != undefined && name != undefined && form != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                if (iscrux != undefined && iscontent != undefined && istype != undefined) {
                    if (res['v_power'] == 0 || res['v_power'] == 1) {
                        modOne = ['公司', iscrux, iscontent, istype, name]
                    } else {
                        modOne = [res["v_form"], iscrux, iscontent, istype, name]
                    }
                    return exeUser.addUserData(conn, sqladd, modOne);
                } else {
                    modTow = "参数不能为空"
                    return false;
                }
            } else {
                modTow = "身份验证错误"
                return false;
            }
        })).catch((reason => {
            console.log(reason);
            //令牌验证失败
            _Log(conn, form, name, '知识库添加', '身份验证错误', '失败', '修改');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (res) {
                _Log(conn, form, name, '知识库添加', '添加成功', '成功', '添加');
                _tips = sendData(200, '添加成功');
                response.json(_tips);
            } else {
                _Log(conn, form, name, '知识库添加', modTow, '失败', '添加');
                _tips = sendData(204, modTow);
                response.json(_tips);
            }
        }))
    }
})

//机构进度查询接口
router.post('/instget', (request, response) => {
    //机构账号待添加数据
    const isuser = request.body.isuser;//机构账号
    const ispass = request.body.ispass;//机构密码
    const sqlcha = sqlUser.user.inst.check[0];//查询机构
    const sqlucha = sqlUser.user.user.check[2];//查询机构账号
    let modOne, modTow;
    if (isuser != undefined && ispass != undefined) {
        exeUser.getUserList(conn, sqlucha, [isuser]).then((res => {
            if (res) {
                if (res.length > 0) {
                    //验证密码
                    if (res[0]['v_passwd'] == md5(ispass)) {
                        modTow = "查询机构数据错误";
                        return exeUser.getUserList(conn, sqlcha, [res[0]['v_form']]);
                    } else {
                        modTow = "查询信息验证错误";
                    }
                } else {
                    console.log("机构不存在");
                    modTow = "查询记录不存在";
                    //查询机构管理员
                    //
                }
            }
        })).catch((reason => {
            _tips = sendData(204, '查询出错');
            response.json(_tips);
        })).then((res => {
            if (res) {
                if (res.length > 0) {
                    _tips = sendData(200, '审核进度查询成功', { 'state': res[0]['v2_examine'] });
                    response.json(_tips);
                } else {
                    _tips = sendData(204, '查询数据为空');
                    response.json(_tips);
                }
            } else {
                _tips = sendData(204, modTow);
                response.json(_tips);
            }
        }))
    }

});

/**
 * POST
 * 机构申请接口
 */
router.post('/instreg', (request, response) => {
    //机构账号待添加数据
    const isuser = request.body.isuser;//机构账号
    const ispass1 = request.body.ispass1;//机构密码1
    const ispass2 = request.body.ispass2;//机构密码2
    //机构待添加数据
    const isname = request.body.isname;//机构名称
    const ispname = request.body.ispname;//联系人姓名
    const isphone = request.body.isphone;//联系人电话
    const iswebsite = request.body.iswebsite;//机构网站
    const isitype = request.body.isitype;//行业类型
    const isitem = request.body.isitem;//经营项目
    const isfund = request.body.isfund;//注册资金

    const sqlcha = sqlUser.user.inst.check[0];//查询机构
    const sqlucha = sqlUser.user.user.check[2];//查询机构账号
    const sqladd = sqlUser.user.inst.add[0];//机构添加语句
    const sqluadd = sqlUser.user.adduser[1];//机构人员添加语句
    const adddata = [isname, ispname, isphone, iswebsite, isitype, isitem, isfund];//机构添加
    const uadddata = [isuser, isuser, md5(ispass1), isname, 5];//机构管理员添加
    let modOne, modTow;
    if (ispass1.length < 6 || ispass2.length < 6) {
        _tips = sendData(204, '密码长度错误');
        response.json(_tips);
    } else {
        if (ispass1 == ispass2) {
            passcheck = true;//
        } else {
            _tips = sendData(204, '两次密码不一致');
            response.json(_tips);
        }
    }
    if (passcheck) {
        exeUser.getUserList(conn, sqlcha, [isname]).then((res => {
            if (res) {
                if (res.length > 0) {
                    console.log("机构已存在");
                    modTow = "机构已存在";
                } else {
                    console.log("机构不存在");
                    //查询机构管理员
                    return exeUser.getUserList(conn, sqlucha, [isuser]);
                }
            }
        })).catch((reason => {
            _tips = sendData(204, '查询出错');
            response.json(_tips);
        })).then((res => {
            if (res) {
                if (res.length > 0) {
                    modTow = "账号已存在";
                } else {
                    //添加机构
                    return exeUser.addUserData(conn, sqladd, adddata)
                }
            }
        })).then((res => {
            if (res) {
                //添加机构管理员
                return exeUser.addUserData(conn, sqluadd, uadddata)
            } else {
                modTow = "机构管理员添加错误,请联系管理员修复";
            }
        })).then((res => {
            if (res) {
                _tips = sendData(200, '申请成功,请留意审核进度！');
                response.json(_tips);
            } else {
                modTow = "机构添加错误,请联系管理员修复";
                _tips = sendData(204, modTow, res);
                response.json(_tips);
            }
        }));
    }
})

/**
 * POST
 * 密钥管理
 */
router.post('/ekey', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const type = request.body.type;//执行操作
    const token = request.body.token;//token
    const sqlcheck = sqlUser.user.token3.check[1];//令牌检查语句
    const sqlckey = sqlUser.user.inst.key[0];//密钥查询语句
    const sqlckey2 = sqlUser.user.inst.key[1];//密钥查询语句
    const sqlukey = sqlUser.user.inst.key[2];//密钥更新语句
    const sqlakey = sqlUser.user.inst.key[3];//密钥添加语句
    const new_key = instkey(name);//获取一个新密钥
    let modOne, modTow;
    //判断是获取还是更新
    if (type == 'up') {
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            if (res) {
                modOne = res;
                //检查key重复
                return exeUser.getUserList(conn, sqlckey2, [new_key]);
            }
        })).catch((reason => {
            //令牌验证失败
            _Log(conn, form, name, 'KEY更新', '身份验证错误', '失败', '修改');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (res) {
                console.log(modOne['v_form']);
                //检查机构KEY存在
                return exeUser.getUserList(conn, sqlckey, [modOne['v_form']]);
            }
        })).then((res => {
            if (res) {
                if (res.length <= 0) {
                    modTow = "KEY新增发生未知错误"
                    return exeUser.addUserData(conn, sqlakey, [modOne['v_form'], new_key, name])
                } else {
                    modTow = "KEY修改发生未知错误"
                    return exeUser.modUserData(conn, sqlukey, [new_key, name, modOne['v_form']]);
                }
            } else {
                modTow = "KEY检查重复发生未知错误";
            }
        })).then((res => {
            if (res) {
                _Log(conn, form, name, 'KEY更新', 'key更新成功', '成功', '修改');
                _tips = sendData(200, 'key更新成功', { 'key': new_key });
                response.json(_tips);
            } else {
                _Log(conn, form, name, 'KEY更新', modTow, '失败', '修改');
                _tips = sendData(204, modTow);
                response.json(_tips);
            }
        }))
    } else {
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            if (res) {
                modOne = res;
                //获取key
                return exeUser.getUserList(conn, sqlckey, [res['v_form']]);
            }
        })).catch((reason => {
            //令牌验证失败
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (res) {
                _tips = sendData(200, '数据获取成功', { "key": res[0]['v3_key'] });
                response.json(_tips);
            } else {
                _tips = sendData(204, '数据获取失败', { "key": '' });
                response.json(_tips);
            }
        }))
    }
});


/**
 * POST
 * 机构审核接口
 */
router.post('/examinemod', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const userid = request.body.id;//机构ID
    const userstate = request.body.state;//审核状态
    const sqlcheck = sqlUser.user.token3.check[0];//令牌检查语句
    const sqllist = sqlUser.user.inst.examine[1];//机构审核语句

    if (token != undefined && name != undefined && form != undefined && userid != undefined) {
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            if (res) {
                //身份验证成功
                return exeUser.modUserData(conn, sqllist, [userstate, userid]);
            }
        })).catch((reason => {
            //令牌验证失败
            _Log(conn, form, name, '机构审核', '身份验证错误', '失败', '修改');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (res) {
                _Log(conn, form, name, '机构审核', '审核通过', '成功', '修改');
                _tips = sendData(200, '审核通过');
                response.json(_tips);
            } else {
                _Log(conn, form, name, '机构审核', "审核失败", '失败', '修改');
                _tips = sendData(204, "审核失败");
                response.json(_tips);
            }
        }))
    }
});

/**
 * POST
 * 机构审核列表
 */
router.post('/examine', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const sqlcheck = sqlUser.user.token3.check[0];//令牌检查语句
    const sqllist = sqlUser.user.inst.examine[0];//列表查询语句
    let modOne, modTwo, Three;
    if (token != undefined && name != undefined && form != undefined) {
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //令牌验证通过
            if (res) {
                modOne = res;
                //未审核数据
                return exeUser.getUserList(conn, sqllist, [0]);
            }
        })).catch((reason => {
            //令牌验证失败
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (res) {
                modTwo = res;
                //已审核数据
                return exeUser.getUserList(conn, sqllist, [1]);
            }
        })).then((res => {
            if (res) {
                Three = res;
                //驳回数据
                return exeUser.getUserList(conn, sqllist, [2]);
            }
        })).then((res => {
            console.log(res);
            if (res) {
                da = {
                    "not": modTwo,
                    "too": Three,
                    "rebut": res
                };
                _tips = sendData(200, '数据获取成功', da);
                response.json(_tips);
            }
        }))
    }
});



/**
 * POST
 * 修改机构
 */
router.post('/instmod', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const instid = request.body.id;//id
    //待修改数据
    const isname = request.body.isname;//机构名称
    const ispname = request.body.ispname;//联系人姓名
    const isphone = request.body.isphone;//联系人电话
    const iswebsite = request.body.iswebsite;//机构网站
    const isitype = request.body.isitype;//行业类型
    const isitem = request.body.isitem;//经营项目
    const isfund = request.body.isfund;//注册资金
    //数据库语句
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqlcha = sqlUser.user.inst.check[0];//查询机构
    const sqlmod = sqlUser.user.inst.mod[0];//修改机构
    const moddata = [isname, ispname, isphone, iswebsite, isitype, isitem, isfund, instid];
    let modOne, modTwo;
    if (token != undefined && name != undefined && form != undefined && instid != undefined) {
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //令牌验证通过
            if (res) {
                modOne = res;
                return exeUser.getUserList(conn, sqlcha, [isname]);
            }
        })).catch((reason => {
            //令牌验证失败
            _Log(conn, form, name, '机构修改', '身份验证错误', '失败', '修改');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (modOne['v_power'] <= 1) {//判断操作者权限
                //判断用户是否已经存在 验证ID区分修改
                console.log(res);
                if (res.length > 0 && res[0]['v2_id'] != instid) {
                    modTwo = "用户名已存在";
                    return false;
                } else {//执行修改操作
                    modTwo = "修改失败";
                    return exeUser.modUserData(conn, sqlmod, moddata);
                }
            } else {
                modTwo = "权限不足";
                return false;
            }
        })).then((res => {
            //修改操作执行成功
            if (res) {
                _Log(conn, form, name, '机构修改', "修改成功", '成功', '修改');
                _tips = sendData(200, '修改成功');
                response.json(_tips);
            } else {
                _Log(conn, form, name, '机构修改', modTwo, '失败', '修改');
                _tips = sendData(204, modTwo);
                response.json(_tips);
            }
        }))
    } else {
        //直接访问返回
        response.status(404).send('Cannot GET 404');
    }
});

/**
 * POST
 * 添加机构
 */
router.post('/instadd', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户角色
    const token = request.body.token;//token

    const isname = request.body.isname;//机构名称
    const ispname = request.body.ispname;//联系人姓名
    const isphone = request.body.isphone;//联系人电话
    const iswebsite = request.body.iswebsite;//机构网站
    const isitype = request.body.isitype;//行业类型
    const isitem = request.body.isitem;//经营项目
    const isfund = request.body.isfund;//注册资金

    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqladd = sqlUser.user.inst.add[0];//机构添加语句
    const sqluse = sqlUser.user.login2[0];//验证管理员语句
    adddata = [isname, ispname, isphone, iswebsite, isitype, isitem, isfund];

    //验证参数
    if (token != undefined && name != undefined && form != undefined && isname != undefined && ispname != undefined && isphone != undefined && iswebsite != undefined && isitype != undefined && isitem != undefined && isfund != undefined) {
        //令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                //验证操作者
                return exeUser.getUserList(conn, sqluse, [name])
            }
        })).catch((reason => {
            //令牌验证失败
            _Log(conn, form, name, '机构添加', '身份验证错误', '失败', '添加');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            //数据查询成功返回
            console.log(res);
            if (res) {
                if (res.length > 0 && res[0]['v_power'] <= 1) {
                    modOne = '机构添加失败';
                    return exeUser.addUserData(conn, sqladd, adddata)
                } else {
                    // console.log(res);
                    modOne = '权限不足';
                    return false;
                }
            }
        })).then((res => {
            if (res) {
                _Log(conn, form, name, '机构添加', '机构添加成功', '成功', '添加');
                _tips = sendData(200, "机构添加成功");
                response.json(_tips);
            } else {
                _Log(conn, form, name, '机构添加', modOne, '失败', '添加');
                _tips = sendData(204, modOne);
                response.json(_tips);
            }
        }));
    } else {
        _tips = sendData(204, '信息填写不完整');
        response.json(_tips);
    }
});



/**
 * POST
 * 修改密码
 */
router.post('/password', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户角色
    const token = request.body.token;//token

    const oldpass = request.body.oldpass;//旧密码
    const npass1 = request.body.newpass1;//新密码1
    const npass2 = request.body.newpass2;//新密码2
    passcheck = false;//
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqllogin = sqlUser.user.login[form];//验证密码语句
    const sqlpass = sqlUser.user.passwd[form];//修改密码语句

    let modOne;
    //如果参数不符合则不执行
    if (token != undefined && name != undefined && form != undefined) {
        if (npass1.length < 6 || npass2.length < 6) {
            _tips = sendData(204, '密码长度错误');
            response.json(_tips);
        } else {
            if (npass1 == npass2) {
                passcheck = true;//
            } else {
                _tips = sendData(204, '两次密码不一致');
                response.json(_tips);
            }
        }
        if (passcheck) {
            //进行令牌验证
            exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
                //如果令牌验证通过
                if (res) {
                    //验证旧密码
                    return exeUser.getUserList(conn, sqllogin, [name, md5(oldpass)])
                }
            })).catch((reason => {
                //令牌验证失败
                _Log(conn, form, name, '密码修改', '身份验证错误', '失败', '修改');
                _tips = sendData(204, '身份验证错误');
                response.json(_tips);
            })).then((res => {
                //数据查询成功返回
                console.log(res);
                if (res) {
                    if (res.length > 0) {
                        modOne = '密码修改失败';
                        return exeUser.modUserData(conn, sqlpass, [md5(npass1), name])
                    } else {
                        // console.log(res);
                        modOne = '原密码错误';
                        return false;
                    }
                }
            })).then((res => {
                if (res) {
                    _Log(conn, form, name, '密码修改', '密码修改成功', '成功', '修改');
                    _tips = sendData(200, "密码修改成功");
                    response.json(_tips);
                } else {
                    _Log(conn, form, name, '密码修改', modOne, '失败', '修改');
                    _tips = sendData(204, modOne);
                    response.json(_tips);
                }
            }));
        }
    } else {
        //直接访问返回
        response.status(404).send('Cannot GET 404');
    }
});

/**
 * POST
 * 机构删除
 */
router.post('/instdel', (request, response) => {
    const name = request.body.name;//用户账号
    const token = request.body.token;//token
    const instid = request.body.id;//ID
    const sqlcheck = sqlUser.user.token3.check[0];//令牌检查语句
    if (token != undefined && name != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            if (res) {
                return exeUser.delUserData(conn, "DELETE FROM v_institution WHERE v2_id = ?;", [instid]);
            } else {
                return false;
            }
        })).catch((reason => {
            //令牌验证失败
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (res) {
                _Log(conn, 0, name, '机构删除', '删除成功', '成功', '删除');
                _tips = sendData(200, '删除成功');
                response.json(_tips);
            } else {
                _Log(conn, 0, name, '机构删除', '操作失败', '失败', '删除');
                _tips = sendData(204, '操作失败');
                response.json(_tips);
            }
        }))
    }

});

/**
 * POST
 * 获取机构角色
 */
router.post('/roleinfo', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//类型
    const token = request.body.token;//token
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqlrole1 = sqlUser.user.info.role[0];//管理员机构列表查询语句
    const sqlrole2 = sqlUser.user.info.role[1];//机构列表查询语句
    const sqlpower1 = sqlUser.user.info.power[0];//机构权限列表查询语句
    const sqlpower2 = sqlUser.user.info.power[1];//管理员权限列表查询语句
    let modOne, modTow;
    //如果参数不符合则不执行
    if (token != undefined && name != undefined && form != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                modTow = res;
                // console.log(res);
                if (res['v_power'] > 1) {
                    //查询数据返回
                    return exeUser.getRoleInfo(conn, sqlrole2, [res['v_form']]);
                } else {
                    //管理员查询数据返回
                    return exeUser.getRoleInfo(conn, sqlrole1, []);
                }
            }
        })).catch((reason => {
            //令牌验证失败
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            //数据查询成功返回
            if (res) {
                modOne = res;
                // console.log(modTow['v_power']);
                if (modTow['v_power'] >= 1) {
                    //查询数据返回
                    return exeUser.getRoleInfo(conn, sqlpower2, [modTow['v_power']]);
                } else {
                    //管理员查询数据返回
                    return exeUser.getRoleInfo(conn, sqlpower1, []);
                }
            }
        })).then((res => {
            if (res) {
                _tips = sendData(200, '数据获取成功', { 'inst': modOne, 'role': res });
                console.log(_tips);
                response.json(_tips);
            }
        }));
    } else {
        //直接访问返回
        response.status(404).send('Cannot GET 404');
    }
});

//机构列表
router.post('/instlist', (request, response) => {
    const name = request.body.name;//用户账号
    const token = request.body.token;//token
    const sqlcheck = sqlUser.user.token3.check[0];//令牌检查语句
    const sqlcha = sqlUser.user.inst.list[0];//机构查询列表
    //如果参数不符合则不执行
    if (token != undefined && name != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                return exeUser.getUserList(conn, sqlcha, [])
            }
        })).catch((reason => {
            //令牌验证失败
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            //数据查询成功返回
            if (res) {
                // console.log(res);
                _tips = sendData(200, '数据获取成功', res);
                console.log(_tips);
                response.json(_tips);
            }
        }));
    } else {
        //直接访问返回
        response.status(404).send('Cannot GET 404');
    }
});

/**
 * POST
 * 人员添加
 */
router.post('/useradd', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户角色
    const token = request.body.token;//token
    const power = request.body.power;//用户权限

    const username = request.body.username;//添加账号
    const userpass1 = request.body.userpass1;//添加密码1
    const userpass2 = request.body.userpass2;//添加密码2
    const userform = request.body.userform;//添加机构
    const userrole = request.body.userrole;//添加角色
    const usertitle = request.body.usertitle;//添加昵称

    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句

    passcheck = false;
    //判断角色
    if (userrole == 0 || userrole == 1) {//公司
        moddata = [username, usertitle, md5(userpass1), userrole];
        sqladd = sqlUser.user.adduser[0];//公司人员添加语句
        sqlcha = sqlUser.user.login2[0];
    } else if (userrole == 4) {//客服
        moddata = [username, usertitle, md5(userpass1), userform, userrole]
        sqladd = sqlUser.user.adduser[2];//客服人员添加语句
        sqlcha = sqlUser.user.login2[2];
    } else {//机构
        moddata = [username, usertitle, md5(userpass1), userform, userrole]
        sqladd = sqlUser.user.adduser[1];//机构人员添加语句
        sqlcha = sqlUser.user.login2[1];
    }
    if (userpass1.length != 0 || userpass2.length != 0) {
        //验证密码长度
        if (userpass1.length >= 6 && userpass2.length >= 6) {
            //验证两次密码是否一致
            if (userpass1 == userpass2) {
                passcheck = true;
            } else {
                _tips = sendData(204, '密码不一致');
                response.json(_tips);
            }
        } else {
            _tips = sendData(204, '密码长度错误');
            response.json(_tips);
        }
    } else {
        _tips = sendData(204, '请输入密码');
        response.json(_tips);
    }
    console.log(moddata);
    let modOne, modTwo;
    //判断密码格式是否正确    
    if (passcheck) {
        //如果参数不符合则不执行
        if (token != undefined && name != undefined && form != undefined) {
            //进行令牌验证
            exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
                //如果令牌验证通过
                if (res) {
                    console.log(res);
                    //验证管理员权限
                    if (res['v_power'] == power) {
                        console.log(1);
                        //判断管理员是否越权添加
                        if (res['v_power'] < userrole || res['v_power'] == 0) {
                            //查询用户
                            return exeUser.getUserList(conn, sqlcha, [username]);
                        } else {
                            modTwo = '权限不足';
                            console.log(2);
                            return false;
                        }
                    } else {
                        modTwo = '违规操作';
                        return false;
                    }
                }
            })).catch((reason => {
                //令牌验证失败
                _Log(conn, form, name, '人员添加', '身份验证错误', '失败', '添加');
                _tips = sendData(204, '身份验证错误');
                response.json(_tips);
            })).then((res => {
                //数据查询成功返回
                console.log(res);
                if (res) {
                    //判断用户是否存在
                    if (res.length > 0) {
                        modTwo = '添加用户已存在';
                        return false;
                    } else {
                        //不存在则添加用户
                        return exeUser.addUserData(conn, sqladd, moddata);
                    }
                }
            })).then((res => {
                if (res) {//判断添加
                    _Log(conn, form, name, '人员添加', '用户添加成功', '成功', '添加');
                    _tips = sendData(200, '用户添加成功', res);
                    console.log(_tips);
                    response.json(_tips);
                } else {
                    _Log(conn, form, name, '人员添加', modTwo, '失败', '添加');
                    _tips = sendData(204, modTwo, res);
                    console.log(_tips);
                    response.json(_tips);
                }
            }));
        } else {
            //直接访问返回
            response.status(404).send('Cannot GET 404');
        }
    }
});


/**
 * POST
 * 管理员修改
 */
router.post('/usermod', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const userid = request.body.id;//id
    const urole = request.body.urole;//角色
    //待修改数据
    const username = request.body.username;//账号
    const usertitle = request.body.usertitle;//昵称
    const userpass1 = request.body.userpass1;//密码1
    const userpass2 = request.body.userpass2;//密码2
    const userform = request.body.userform;//所属机构
    passcheck = false;//
    //数据库语句
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqlcha = sqlUser.user.login2[urole];
    console.log(userpass1, userpass2);
    //验证密码格式
    if (userpass1.length > 0 || userpass2.length > 0) {
        //验证密码长度
        if (userpass1.length >= 6 && userpass2.length >= 6) {
            //验证两次密码是否一致
            if (userpass1 == userpass2) {
                //判断角色(修改密码)
                if (urole == 0) {
                    sqlmod = sqlUser.user.admin.mod[0];//公司
                } else {
                    sqlmod = sqlUser.user.user.mod[0];//机构
                }
                moddata = [username, md5(userpass1), usertitle, userid];
                passcheck = true;
            } else {
                _tips = sendData(204, '密码不一致');
                response.json(_tips);
            }
        } else {
            _tips = sendData(204, '密码长度错误');
            response.json(_tips);
        }
    } else {
        //判断角色(不修改密码)
        if (urole == 0) {
            sqlmod = sqlUser.user.admin.mod[1];//公司
        } else {
            sqlmod = sqlUser.user.user.del[1];//机构
        }
        moddata = [username, usertitle, userid];
        passcheck = true;
    }
    let modOne, modTwo;
    //判断是否修改密码
    if (passcheck) {
        if (token != undefined && name != undefined && form != undefined && userid != undefined) {
            exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
                //令牌验证通过
                if (res) {
                    modOne = res;
                    return exeUser.getUserList(conn, sqlcha, [username]);
                }
            })).catch((reason => {
                //令牌验证失败
                _Log(conn, form, name, '管理员信息修改', '身份验证错误', '失败', '修改');
                _tips = sendData(204, '身份验证错误');
                response.json(_tips);
            })).then((res => {
                if (modOne['v_power'] <= 2) {//判断操作者权限
                    //判断用户是否已经存在 验证ID区分修改
                    console.log(res);
                    if (res.length > 0 && res[0]['v_id'] != userid) {
                        modTwo = "用户名已存在";
                        return false;
                    } else {//执行修改操作
                        modTwo = "修改失败";
                        return exeUser.modUserData(conn, sqlmod, moddata);
                    }
                } else {
                    modTwo = "权限不足";
                    return false;
                }
            })).then((res => {
                //修改操作执行成功
                if (res) {
                    _Log(conn, form, name, '管理员信息修改', '修改成功', '成功', '修改');
                    _tips = sendData(200, '修改成功');
                    response.json(_tips);
                } else {
                    _Log(conn, form, name, '管理员信息修改', modTwo, '失败', '修改');
                    _tips = sendData(204, modTwo);
                    response.json(_tips);
                }
            }))
        } else {
            //直接访问返回
            response.status(404).send('Cannot GET 404');
        }
    }
});

/**
 * POST
 * 管理员删除
 */
router.post('/userdel', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const power = request.body.power;//用户权限

    const userid = request.body.id;//id
    const urole = request.body.urole;//被删除账号角色
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    //判断角色
    if (urole == 0) {
        sqldel = sqlUser.user.admin.del[0];//超级管理员删除语句
        sqlcha = sqlUser.user.admin.check[1];
    } else {
        sqldel = sqlUser.user.user.del[0];//管理员删除语句
        sqlcha = sqlUser.user.user.check[1];
    }
    let modOne, modTwo;
    if (power < '2' && token != undefined && name != undefined && form != undefined && userid != undefined) {
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            if (res) {
                console.log(res);
                modOne = res;
                //二次验证权限
                return exeUser.getUserList(conn, sqlcha, [userid]);
            }
        })).catch((reason => {
            //令牌验证失败
            _Log(conn, form, name, '管理员删除', '身份验证错误', '失败', '删除');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            //判断删除用户是否存在
            if (res) {
                // console.log(res.length);
                if (res.length > 0) {
                    //判断删除用户是否权限大于或等于删除者权限
                    if (res[0]['v_power'] > modOne['v_power'] && res[0]['v_name'] != name) {
                        console.log(1);
                        return exeUser.delUserData(conn, sqldel, [userid.split(",")]);
                    } else {
                        modTwo = '权限不足';
                        return false;
                    }
                } else {
                    modTwo = '删除用户不存在';
                    return false;
                }
            }
        })).then((res => {
            if (res) {
                _Log(conn, form, name, '管理员删除', '删除成功', '成功', '删除');
                _tips = sendData(200, '删除成功');
                response.json(_tips);
            } else {
                _Log(conn, form, name, '管理员删除', modTwo, '失败', '删除');
                _tips = sendData(204, modTwo);
                response.json(_tips);
            }
        }))
    } else {
        //直接访问返回
        response.status(404).send('Cannot GET 404');
    }
});

/**
 * POST
 * 管理员列表
 */
router.post('/userlist', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//类型
    const token = request.body.token;//token
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqladmin = sqlUser.user.admin.check[0];//公司管理员列表语句
    const sqluse = sqlUser.user.user.check[0];//机构管理员列表语句
    let modOne, modTwo, modThree;
    //如果参数不符合则不执行
    if (token != undefined && name != undefined && form != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                console.log(res);
                modThree = res['v_power'];
                //公司超级管理与机构最高管理可编辑
                if (modThree == 0 || modThree == 2) {
                    modTwo = true;
                } else {
                    modTwo = false;
                }
                console.log(modTwo);
                //判断当前请求者身份
                if (modThree == 0 || modThree == 1) {
                    //查询数据返回
                    return exeUser.getUserList(conn, sqladmin, [modThree]);
                } else {
                    //查询数据返回
                    return exeUser.getUserList(conn, sqluse, []);
                }
            }
        })).catch((reason => {
            //令牌验证失败
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            //数据查询成功返回
            if (res) {
                if (modThree == '0' || modThree == 1) {
                    modOne = res;
                    console.log(res);
                    return exeUser.getUserList(conn, sqluse, []);
                } else {
                    console.log(2222);
                    _tips = sendData(200, '数据获取成功', res, 1, modTwo);
                    console.log(_tips);
                    response.json(_tips);
                    return false;
                }
            }
        })).then((res => {
            if (res) {
                console.log(modOne);
                if (modThree == '0' || modThree == 1) {
                    //追加数据
                    let _dat = modOne.concat(res);
                    _tips = sendData(200, '数据获取成功', _dat, 1, modTwo);
                    // console.log(_tips);
                    response.json(_tips);
                }
            }
        }));
    } else {
        //直接访问返回
        response.status(404).send('Cannot GET 404');
    }
    console.log('userlist');
});

/**
 * POST
 * 客服账户修改
 */
router.post('/kefumod', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const kefuid = request.body.id;//id
    //待修改数据
    const kufuname = request.body.kfname;//客服账号
    const kefutitle = request.body.kftitle;//客服昵称
    const kefupass1 = request.body.kfpass1;//密码1
    const kefupass2 = request.body.kfpass2;//密码2
    const kfform = request.body.kfform;//客服所属机构
    passcheck = false;//
    //数据库语句
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqlkefu = sqlUser.user.login2[2];
    console.log(kefupass1, kefupass2);
    //验证密码格式
    if (kefupass1.length != 0 || kefupass2.length != 0) {
        //验证密码长度
        if (kefupass1.length >= 6 && kefupass2.length >= 6) {
            //验证两次密码是否一致
            if (kefupass1 == kefupass2) {
                sqlkfmod = sqlUser.user.kefu.mod[0];//客服修改语句
                modkfdata = [kufuname, md5(kefupass1), kefutitle, kfform, kefuid];
                passcheck = true;
            } else {
                _tips = sendData(204, '密码不一致');
                response.json(_tips);
            }
        } else {
            _tips = sendData(204, '密码长度错误');
            response.json(_tips);
        }
    } else {
        sqlkfmod = sqlUser.user.kefu.mod[1];//客服修改语句(不修改密码)
        modkfdata = [kufuname, kefutitle, kfform, kefuid];
        passcheck = true;
    }

    //判断是否修改密码
    if (passcheck) {
        if (token != undefined && name != undefined && form != undefined && kefuid != undefined) {
            exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
                //令牌验证通过
                if (res) {
                    return exeUser.getUserList(conn, sqlkefu, [kufuname]);
                }
            })).catch((reason => {
                //令牌验证失败
                _Log(conn, form, name, '客服账户修改', '身份验证错误', '失败', '修改');
                _tips = sendData(204, '身份验证错误');
                response.json(_tips);
            })).then((res => {
                //判断用户是否已经存在 验证ID区分修改
                if (res.length > 0 && res[0]['v_id'] != kefuid) {
                    _tips = sendData(204, '用户名已存在');
                    response.json(_tips);
                } else {//执行修改操作
                    return exeUser.modUserData(conn, sqlkfmod, modkfdata);
                }
            })).then((res => {
                //修改操作执行成功
                if (res) {
                    _Log(conn, form, name, '客服账户修改', '修改成功', '成功', '修改');
                    _tips = sendData(200, '修改成功');
                    response.json(_tips);
                } else {
                    _Log(conn, form, name, '客服账户修改', '修改失败', '失败', '修改');
                    _tips = sendData(204, '修改失败');
                    response.json(_tips);
                }
            }))
        } else {
            //直接访问返回
            response.status(404).send('Cannot GET 404');
        }
    }
})

/**
 * POST
 * 客服账号删除
 */
router.post('/kefudel', (request, response) => {
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户类型
    const token = request.body.token;//token
    const power = request.body.power;//用户权限
    const kefuid = request.body.id;//id
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqldel = sqlUser.user.kefu.del[0];//客服删除语句
    if (power <= '2' && token != undefined && name != undefined && form != undefined && kefuid != undefined) {
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            if (res) {
                //二次验证权限
                if (res['v_power']) {
                    console.log(sqldel);
                    return exeUser.delUserData(conn, sqldel, [kefuid.split(",")]);
                }
            }
        })).catch((reason => {
            //令牌验证失败
            _Log(conn, form, name, '客服账号删除', '身份验证错误', '失败', '删除');
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            if (res) {
                _Log(conn, form, name, '客服账号删除', '删除成功', '成功', '删除');
                _tips = sendData(200, '删除成功');
                response.json(_tips);
            } else {
                _Log(conn, form, name, '客服账号删除', '删除失败', '失败', '删除');
                _tips = sendData(204, '删除失败');
                response.json(_tips);
            }
        }))
    } else {
        //直接访问返回
        response.status(404).send('Cannot GET 404');
    }
});

/**
 * POST
 * 客服列表
 */
router.post('/kefulist', (request, response) => {
    //query ?name=admin&form=0&token=d48f9f9ee663f7848578378d489ca8ff
    const name = request.body.name;//用户账号
    const form = request.body.form;//类型
    const token = request.body.token;//token
    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句
    const sqlkefu = sqlUser.user.kefu.check[0];//客服列表语句
    const sqlkefu2 = sqlUser.user.kefu.check[1];//客服列表语句2
    //如果参数不符合则不执行
    if (token != undefined && name != undefined && form != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {
                console.log(res);
                if (res['v_power'] > 1) {
                    //查询数据返回
                    return exeUser.getUserList(conn, sqlkefu, [res['v_form']]);
                } else {
                    //管理员查询数据返回
                    return exeUser.getUserList(conn, sqlkefu2, []);
                }
            }
        })).catch((reason => {
            //令牌验证失败
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            //数据查询成功返回
            if (res) {
                // console.log(res);
                _tips = sendData(200, '数据获取成功', res);
                console.log(_tips);
                response.json(_tips);
            }
        }));
    } else {
        //直接访问返回
        response.status(404).send('Cannot GET 404');
    }
    console.log('kefulist');
});


/**
 * POST
 * 用户登录
 */
router.post('/login', (request, response) => {
    const username = request.body.username;//用户账号
    const userpasswd = request.body.userpasswd;//用户密码
    const userform = request.body.userform;//类型
    const sqllogin = sqlUser.user.login[userform];//获取数据库语句1
    const sqltoken = sqlUser.user.token[userform];//获取数据库语句1
    const sqllogintime = sqlUser.user.token[userform];//获取数据库语句1
    const intologin = [username, md5(userpasswd)];//数据库注入数据
    let modOne, token, title;//定义用于接收数据的全局变量
    console.log(new Date());
    //调用自定义模块进行登录
    exeLogin.login(conn, sqllogin, intologin, response).then((res => {
        modOne = res;//储存数据
        //判断用户是否存在
        if (res != null) {
            //生成令牌
            token = md5(res['v1_name'] + md5(new Date()));
            return exeLogin.uptoken(conn, sqltoken, username, token, new Date())
        }
    })).catch((reason => {
        // 自定义令牌更新失败返回数据
        _Log(conn, userform, username, '用户登录', '登录失败', '失败', '登录');
        _tips = sendData(204, '账号密码错误');
        response.json(_tips);
    })).then((res) => {
        console.log(res);
        if (res) {//登录验证成功
            _Log(conn, userform, username, '用户登录', '登录成功', '成功', '登录');
            // exeUser.modUserData(conn);
            //判断是否为客服
            if (modOne['v_power'] != '4') {
                title = modOne['v_name'];
            } else {
                title = modOne['v_title'];
            }
            //自定义登录成功返回数据
            _tips = sendData(200, '登录成功', {
                "title": title,//昵称
                "token": token,//令牌
                "power": modOne['v_power'],//权限
            });
            console.log(_tips);
            response.json(_tips);
        }
    });
    console.log('login');
});



router.get('/cs', function (err, res) {
    var ip = '';
    console.log(ip);

    res.json(ip);
    // //2019-11-27T12:10:45.701Z
    // //2019-11-27T11:53:25.000Z
    // var oDate1 = new Date("2019-11-27T12:10:45.701Z");
    // var oDate2 = new Date("2019-11-27T11:53:25.000Z");
    // if (oDate1 > oDate2) {
    //     console.log('第一个大', oDate1);
    // } else {
    //     console.log('第二个大');
    // }

    // var oDate1 = new Date('2019-11-27T20:53:25.000Z');
    // var oDate2 = new Date();

    // var ctime = ((((oDate2 - oDate1) / 1000) / 60) + (8 * 60)).toFixed(2);
    // console.log(oDate2);

    // // var time = Date.now();
    // // console.log(oDate1 - oDate2);
    // // var t = new Date('yyyy-MM-dd');
    // // console.log(t);
    // // // 当前时间
    // // var date = new Date();
    // // var time = date.getTime();
    // let aaad = '1,2,3';
    // let aacc = [aaad]
    // ss = aaad.split(",");
    // console.log(ss);
    // console.log(aaad.split(","));

    // res.json(ss);
})

// 这里就是主要要修改的地方，其实也就一行
// 把 address 改成你自己定的地址，就是连接访问的那个地址
router.get('/address', function (err, res) {
    const sql = "select * from ?"; // 写你需要的sql代码，你要是不会写那我就真的没办法了
    console.log(md5(sql));
    console.log(err.query.u);//获取get数据
    conn.query(sql, ['v_admin'], function (err, result) {
        if (err) {
            console.log('[SELECT ERROR] - ', err.message);
            return;
        }
        // result内放的就是返回的数据，res是api传数据
        // 返回的数据需要转换成JSON格式
        res.json(result);
    });
})

router.post('/1', function (request, response) {
    console.log(request.body.user);//获取POST数据
    const name = request.body.name;//用户账号
    const form = request.body.form;//用户角色
    const token = request.body.token;//token
    const power = request.body.power;//用户权限

    const username = request.body.username;//添加账号
    const userpass1 = request.body.userpass1;//添加密码1
    const userpass2 = request.body.userpass2;//添加密码2
    const userform = request.body.userform;//添加机构
    const userrole = request.body.userrole;//添加角色
    const usertitle = request.body.usertitle;//添加昵称

    const sqlcheck = sqlUser.user.token3.check[form];//令牌检查语句

    //如果参数不符合则不执行
    if (token != undefined && name != undefined && form != undefined) {
        //进行令牌验证
        exeLogin.checktoken(conn, sqlcheck, [name, token]).then((res => {
            //如果令牌验证通过
            if (res) {

            }
        })).catch((reason => {
            //令牌验证失败
            _tips = sendData(204, '身份验证错误');
            response.json(_tips);
        })).then((res => {
            //数据查询成功返回
            if (res) {
                // console.log(res);
                _tips = sendData(200, '数据获取成功', res);
                console.log(_tips);
                response.json(_tips);
            }
        }));
    } else {
        //直接访问返回
        response.status(404).send('Cannot GET 404');
    }
})

module.exports = router;